home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / XBD2_SRC.ZIP / XBD2_SRC / BITMAP.C next >
Encoding:
C/C++ Source or Header  |  1991-02-08  |  8.1 KB  |  402 lines
  1. /*********************************************/
  2. /*                                           */
  3. /*      Editor for all bitmaps                */
  4. /*                                           */
  5. /*      PC-VGA version from :                */
  6. /*                                           */
  7. /*        Herve SOULARD, Paris, 1990        */
  8. /*                                           */
  9. /*********************************************/
  10.  
  11. #include <stdio.h>
  12. #include <malloc.h>
  13. #include <graph.h>
  14.  
  15. #define    X_OFF    100
  16. #define    Y_OFF    100
  17.  
  18. #define    X_SIZE    10
  19. #define    Y_SIZE    10
  20.  
  21. #define    WIDTH        16
  22. #define    HEIGHT    16
  23.  
  24. #define    MAXPGM    23
  25.  
  26. struct videoconfig config;
  27. int sizePgm;
  28.  
  29. char *pgms[MAXPGM];
  30. char *bitmap[MAXPGM];
  31. char *name[MAXPGM];
  32.  
  33.  
  34. void makePgm(char bitmap[],char pgms[])
  35. {
  36.     char *ptr,c;
  37.     int i,j;
  38.     unsigned r1,r2,r3,r4;
  39.     unsigned *uptr;
  40.     
  41.     ptr = pgms;
  42.     uptr = (unsigned *)pgms;
  43.     
  44.     if (ptr == NULL) {
  45.         printf ("Erreur allocation (pgms)\n");
  46.         exit(1);
  47.     }    
  48.  
  49.     *ptr = WIDTH;
  50.     *(ptr+2) = HEIGHT;
  51.     *(ptr+1) = *(ptr+3) = 0;
  52.  
  53.     for (i=0; i < HEIGHT;i++) {
  54.         r1 = r2 = r3 = r4 = 0;
  55.         for (j=0; j < WIDTH; j++) {
  56.             c = bitmap[(i*WIDTH)+j];
  57.             if (c & 0x01)
  58.                 r1 |= (1 << ((WIDTH-1)-j));
  59.             if (c & 0x02)
  60.                 r2 |= (1 << ((WIDTH-1)-j));
  61.             if (c & 0x04)
  62.                 r3 |= (1 << ((WIDTH-1)-j));
  63.             if (c & 0x08)
  64.                 r4 |= (1 << ((WIDTH-1)-j));
  65.         }
  66.         /*
  67.             For compatibility with _putimage from Microsoft
  68.             
  69.         *(uptr+2+(i*4)) = r1;
  70.         *(uptr+2+(i*4)+1) = r2;
  71.         *(uptr+2+(i*4)+2) = r3;
  72.         *(uptr+2+(i*4)+3) = r4;
  73.         */
  74.  
  75.         /*    Using my own _putimage (drawPgm)
  76.         */
  77.         *(uptr+2+i) = r1;
  78.         *(uptr+2+i+16) = r2;
  79.         *(uptr+2+i+32) = r3;
  80.         *(uptr+2+i+48) = r4;
  81.     }
  82.     for (i=4; i< sizePgm; i+=2) {
  83.         c = *(ptr+i);
  84.         *(ptr+i) = *(ptr+i+1);
  85.         *(ptr+i+1) = c;
  86.     }
  87. }
  88.  
  89.  
  90. void makePgms()
  91. {
  92.     int i;
  93.     
  94.     for (i = 0; i < MAXPGM;i++) {
  95.         pgms[i] = (char *)malloc(sizePgm);
  96.         makePgm(bitmap[i],pgms[i]);
  97.     }
  98. }
  99.  
  100. void drawBitmap(int num)
  101. {
  102.     char c;
  103.     int i,j;
  104.     int x,y;
  105.     char *ptrBitmap;
  106.  
  107.     
  108.     ptrBitmap = bitmap[num];
  109.     makePgm(ptrBitmap,pgms[num]);
  110.     
  111.     drawPgm(num, 1, pgms[num], _GPSET);
  112.  
  113.     _settextposition(3, 0);
  114.     _outtext("                                                                               ");
  115.     
  116.     _setcolor(15);
  117.     _rectangle(_GFILLINTERIOR, 7 + (16 * num), 36, 9 + (16 * num), 41);
  118.     
  119.     _settextposition(5,50);
  120.     _outtext("                    ");
  121.     _settextposition(5,50);
  122.     _outtext(name[num]);
  123.     
  124.     for (i=0; i < HEIGHT;i++) {
  125.         y = (i*(Y_SIZE+2)) + Y_OFF;
  126.         for (j=0; j < WIDTH; j++) {
  127.             c = ptrBitmap[(i*WIDTH)+j];
  128.             _setcolor(c);
  129.             x = (j*(X_SIZE+2)) + X_OFF;
  130.             _rectangle(_GFILLINTERIOR, x, y, x + X_SIZE, y + Y_SIZE);
  131.         }
  132.     }
  133. }
  134.  
  135.  
  136. void drawColor()
  137. {
  138.     int i;
  139.     int y;
  140.     
  141.     for (i=0;i<16;i++) {
  142.         _setcolor(i);
  143.         y = Y_OFF + (i*2*Y_SIZE);
  144.         _rectangle(_GFILLINTERIOR, 450, y + 5,
  145.             450 + 2 * X_SIZE, y + 2 * Y_SIZE);
  146.     }
  147. }
  148.  
  149. void setCursor(xC,yC,bitmap)
  150. int xC,yC;
  151. char bitmap[];
  152. {
  153.     char *ptr,c;
  154.     int x,y;
  155.  
  156.     c = bitmap[(yC*WIDTH)+xC];
  157.     _setcolor(15 - c);
  158.     y = (yC*(Y_SIZE+2)) + Y_OFF;
  159.     x = (xC*(X_SIZE+2)) + X_OFF;
  160.     _rectangle(_GBORDER, x, y, x + X_SIZE, y + Y_SIZE);
  161. }
  162.  
  163.  
  164. void unsetCursor(xC,yC,bitmap)
  165. int xC,yC;
  166. char bitmap[];
  167. {
  168.     char *ptr,c;
  169.     int x,y;
  170.  
  171.     c = bitmap[(yC*WIDTH)+xC];
  172.     _setcolor(c);
  173.     y = (yC*(Y_SIZE+2)) + Y_OFF;
  174.     x = (xC*(X_SIZE+2)) + X_OFF;
  175.     _rectangle(_GBORDER, x, y, x + X_SIZE, y + Y_SIZE);
  176. }
  177.  
  178. void setColor(xC,yC,bitmap)
  179. int xC,yC;
  180. char bitmap[];
  181. {
  182.     char c;
  183.     int aux;
  184.  
  185.     c = bitmap[(yC*WIDTH)+xC];
  186.     _setcolor(c);
  187.     aux = Y_OFF + (c*2*Y_SIZE);
  188.     _rectangle(_GFILLINTERIOR, 480, aux + 5, 480+ 2*X_SIZE, aux + 2*Y_SIZE);
  189. }
  190.  
  191.  
  192. void unsetColor(xC,yC,bitmap)
  193. int xC,yC;
  194. char bitmap[];
  195. {
  196.     char c;
  197.     int aux;
  198.  
  199.     c = bitmap[(yC*WIDTH)+xC];
  200.     _setcolor(0);
  201.     aux = Y_OFF + (c*2*Y_SIZE);
  202.     _rectangle(_GFILLINTERIOR, 480, aux + 5, 480+ 2*X_SIZE, aux + 2*Y_SIZE);
  203. }
  204.  
  205. void load()
  206. {
  207.     FILE *map;
  208.     int i,j,k;
  209.     char buf[300];
  210.     int *ptr;
  211.     char *aux;
  212.     int color[WIDTH];
  213.     
  214.     strcpy(buf,"bitmaps.dat");
  215.     map = fopen(buf,"r");
  216.     if (map == 0) {
  217.         printf("Erreur d'ouverture du fichier\n");
  218.     }
  219.     else {
  220.         for (i = 0;i < MAXPGM;i++) {
  221.             fgets(buf,300,map);
  222.             bitmap[i] = (char *)malloc(HEIGHT * WIDTH);
  223.             name[i] = (char *)malloc(80);
  224.             sscanf(buf,"%s",name[i]);
  225.             for (j = 0;j < HEIGHT;j++) {
  226.                 ptr = color;
  227.                 fgets(buf,300,map);
  228.                 sscanf(buf,"%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
  229.                         ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,
  230.                          ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr);
  231.                 for (k = 0; k < WIDTH;k++)
  232.                     bitmap[i][(j*WIDTH)+k] = (char)color[k];
  233.             }
  234.             fgets(buf,300,map);
  235.  
  236.         }
  237.         fclose(map);
  238.     }
  239. }
  240.  
  241. void save()
  242. {
  243.     FILE *map;
  244.     char filename[20];
  245.     int i,j,k;
  246.     
  247.     strcpy(filename,"bitmaps.dat");
  248.     map = fopen(filename,"w");
  249.     if (map == 0) {
  250.         printf("Erreur d'ouverture du fichier\n");
  251.     }
  252.     else {
  253.         for (i = 0;i < MAXPGM;i++) {
  254.             fprintf(map,"%s %2d\n",name[i],i);
  255.             for (j = 0;j < HEIGHT;j++) {
  256.                 fprintf(map,"\t");
  257.                 for (k = 0;k < WIDTH;k++) 
  258.                     fprintf(map,"%2d ",bitmap[i][(j*WIDTH)+k]);
  259.                 fprintf(map,"\n");
  260.             }
  261.             fprintf(map,"\t\n");
  262.         }
  263.         fclose(map);
  264.     }
  265. }
  266.  
  267.  
  268. main()
  269. {
  270.     int fin = 0;
  271.     char keyhit;
  272.     int num = 0;
  273.     int x = 0;
  274.     int y = 0;
  275.     int color = 15;
  276.     int aux;
  277.     
  278.     _setvideomode(_MAXRESMODE);
  279.     _getvideoconfig(&config);
  280.     sizePgm = (unsigned int)_imagesize(0,0,WIDTH-1,HEIGHT-1);
  281.  
  282.     load();
  283.     makePgms();
  284.     
  285.     for (aux=0;aux < MAXPGM; aux++)
  286.         drawPgm(aux, 1, pgms[aux], _GPSET);
  287.  
  288.     drawBitmap(num);
  289.  
  290.     drawColor();
  291.     
  292.     _setcolor(color);
  293.     aux = Y_OFF + (color*2*Y_SIZE);
  294.     _rectangle(_GFILLINTERIOR, 420, aux + 5, 420+ 2*X_SIZE, aux + 2*Y_SIZE);
  295.  
  296.     while (!fin) {
  297.         setCursor(x,y,bitmap[num]);
  298.         if (kbhit()) {
  299.             keyhit = getch();
  300.             if (keyhit == 0 || keyhit == 0xE0)
  301.                 keyhit = getch();
  302.             switch (keyhit) {
  303.                 case 32 :
  304.                     unsetColor(x,y,bitmap[num]);
  305.                     bitmap[num][(y*16)+x] = color;
  306.                     drawBitmap(num);
  307.                     setColor(x,y,bitmap[num]);
  308.                     break;
  309.                 case 75 :
  310.                     unsetCursor(x,y,bitmap[num]);
  311.                     unsetColor(x,y,bitmap[num]);
  312.                     if (--x < 0)
  313.                         x = WIDTH-1;
  314.                     setCursor(x,y,bitmap[num]);
  315.                     setColor(x,y,bitmap[num]);
  316.                     break;
  317.                 case 72 :
  318.                     unsetCursor(x,y,bitmap[num]);
  319.                     unsetColor(x,y,bitmap[num]);
  320.                     if (--y < 0)
  321.                         y = HEIGHT-1;
  322.                     setCursor(x,y,bitmap[num]);
  323.                     setColor(x,y,bitmap[num]);
  324.                     break;
  325.                 case 80 :
  326.                     unsetCursor(x,y,bitmap[num]);
  327.                     unsetColor(x,y,bitmap[num]);
  328.                     if (++y > HEIGHT-1)
  329.                         y = 0;
  330.                     setCursor(x,y,bitmap[num]);
  331.                     setColor(x,y,bitmap[num]);
  332.                     break;
  333.                 case 77 :
  334.                     unsetCursor(x,y,bitmap[num]);
  335.                     unsetColor(x,y,bitmap[num]);
  336.                     if (++x > WIDTH-1)
  337.                         x = 0;
  338.                     setCursor(x,y,bitmap[num]);
  339.                     setColor(x,y,bitmap[num]);
  340.                     break;
  341.                 case 73 :
  342.                     unsetCursor(x,y,bitmap[num]);
  343.                     unsetColor(x,y,bitmap[num]);
  344.                     x = y = 0;
  345.                     if (++num > MAXPGM-1)
  346.                         num = 0;
  347.                     drawBitmap(num);
  348.                     setCursor(x,y,bitmap[num]);
  349.                     setColor(x,y,bitmap[num]);
  350.                     break;
  351.                 case 81 :
  352.                     unsetCursor(x,y,bitmap[num]);
  353.                     unsetColor(x,y,bitmap[num]);
  354.                     x = y = 0;
  355.                     if (--num < 0)
  356.                         num = MAXPGM-1;
  357.                     drawBitmap(num);
  358.                     setCursor(x,y,bitmap[num]);
  359.                     setColor(x,y,bitmap[num]);
  360.                     break;
  361.                 case 'S' :
  362.                 case 's' :
  363.                     save();
  364.                     break;
  365.                 case '+' :
  366.                     _setcolor(0);
  367.                     aux = Y_OFF + (color*2*Y_SIZE);
  368.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  369.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  370.                     if (++color > 15)
  371.                         color = 0;
  372.                     _setcolor(color);
  373.                     aux = Y_OFF + (color*2*Y_SIZE);
  374.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  375.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  376.  
  377.                     break;
  378.                 case '-' :
  379.                     _setcolor(0);
  380.                     aux = Y_OFF + (color*2*Y_SIZE);
  381.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  382.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  383.                     if (--color < 0)
  384.                         color = 15;
  385.                     _setcolor(color);
  386.                     aux = Y_OFF + (color*2*Y_SIZE);
  387.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  388.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  389.                     break;
  390.                 case 27 :
  391.                     fin = 1;
  392.                     break;
  393.             }
  394.         }
  395.         unsetCursor(x,y,bitmap[num]);
  396.     }
  397.     
  398.     _setvideomode(_DEFAULTMODE);
  399.     exit(0);
  400. }
  401.  
  402.